package com.toolset.Activity.ToolItemActivity;

import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import com.toolset.Activity.BaseActivity;
import com.toolset.R;

import java.math.BigInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
//https://www.cnblogs.com/lws520/p/5818456.html  多个EditText 监听矛盾的 解决办法 （Overstack）溢出栈
难点  editText 使用 addTextChangedListener
多个EditText 使用addTextChangedListener 如果不加限制递归 导致溢出栈问题
需要使用一个boolean变量解决该问题

                if(autoChange){
                    autoChange =false;
                    return;
                }

                当autoChange为 true 时 修改为false  并返回 下次如果为false 则执行接下来的addTextChangedListener
                并且在display之前设置回false
 */
//进制转换
public class BinaryConversion extends BaseActivity {

    private Button two_sys_copy;  //二进制复制按钮
    private Button eight_sys_copy;   //八进制复制按钮
    private Button ten_sys_copy;     //十进制复制按钮
    private Button sixteen_sys_copy;   //十六进制复制按钮
    private Button cleanBtn;   //清空按钮




    private EditText two_sys;  //二进制文本框
    private EditText eight_sys;  //八进制文本框
    private EditText ten_sys;  //十进制文本框
    private EditText sixteen_sys;  //十六进制文本框

    private boolean autoChange = false;   //解决多个EditText监听导致 溢出栈问题

    String two;  //二进制字符串
    String eight; //八进制字符串
    String ten;  //十进制字符串
    String sixteen; //十六进制字符串

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_binary_conversion);

        //初始化
        initEvent();


        //点击复制
        copy(BinaryConversion.this,two_sys_copy,two_sys);
        copy(BinaryConversion.this,eight_sys_copy,eight_sys);
        copy(BinaryConversion.this,ten_sys_copy,ten_sys);
        copy(BinaryConversion.this,sixteen_sys_copy,sixteen_sys);

        //转换 2 8 10 16操作
        conversionBinary(two_sys,2);
        conversionBinary(eight_sys,8);
        conversionBinary(ten_sys,10);
        conversionBinary(sixteen_sys,16);

        //清空按钮
        cleanBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                two_sys.setText("");
                eight_sys.setText("");
                ten_sys.setText("");
                sixteen_sys.setText("");
                Toast.makeText(BinaryConversion.this,"清空成功！", Toast.LENGTH_SHORT).show();
            }
        });

    }

    //初始化
    private void initEvent() {
        two_sys_copy = (Button) findViewById(R.id.two_sys_copy);
        two_sys = (EditText) findViewById(R.id.two_sys);

        eight_sys_copy = (Button) findViewById(R.id.eight_sys_copy);
        eight_sys = (EditText) findViewById(R.id.eight_sys);

        ten_sys_copy = (Button) findViewById(R.id.ten_sys_copy);
        ten_sys = (EditText) findViewById(R.id.ten_sys);

        sixteen_sys_copy = (Button) findViewById(R.id.sixteen_sys_copy);
        sixteen_sys = (EditText) findViewById(R.id.sixteen_sys);

        cleanBtn = (Button) findViewById(R.id.cleanBtn);
    }




    //转换进制  参数 文本框  进制
    private void conversionBinary(final EditText editText, final int binary){// 2 8 10 16


        //监听EditText 输入 回调函数
        editText.addTextChangedListener(new TextWatcher() {


            //输入前
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            //输入中
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

            }

            //输入结束后
            @Override
            public void afterTextChanged(Editable s) {

                // 当autochange 为true 时  修改为false  拦截接下来计算操作 防止异常回调 内存泄漏
                //https://www.cnblogs.com/lws520/p/5818456.html  多个EditText 监听矛盾的 解决办法 （Overstack）溢出栈
                if(autoChange){
                    autoChange =false;
                    return;
                }

                // 当长度大于0 再进去一下函数体 防止空值转换
                if (s.length()>0) {

                    //获取当前文本框字符串
                    String inputText  = s.toString();

                        switch (binary) {
                            case 2:

                                binaryConversion(inputText,2); //进制转换
                                display(two, eight, ten, sixteen);  //显示到界面
                                two_sys.setSelection(two_sys.length());  //游标放到最后

                                break;
                            case 8:
                                binaryConversion(inputText,8); //进制转换
                                display(two, eight, ten, sixteen);  //显示到界面
                                eight_sys.setSelection(eight_sys.length());  //游标放到最后
                                break;
                            case 10:

                                binaryConversion(inputText,10); //进制转换
                                display(two, eight, ten, sixteen);  //显示到界面
                                ten_sys.setSelection(ten_sys.length());  //游标放到最后

                                break;
                            case 16:

                                //十六进制特殊匹配
                                String regEx = "[^a-fA-F0-9]*";  //只能输入字母或数字
                                Pattern p = Pattern.compile(regEx);
                                Matcher m = p.matcher(inputText);
                                String str = m.replaceAll("").trim();    //删掉不是字母或数字的字符

                                binaryConversion(str,16); //进制转换
                                display(two, eight, ten, sixteen);  //显示到界面
                                sixteen_sys.setSelection(sixteen_sys.length());  //游标放到最后

                                break;
                        }

                }


            }
        });

    }



    //系统剪贴板-复制:   s为内容
    //https://blog.csdn.net/qq_39731011/article/details/81505858
    public static void copy(final  Context context, Button btn, final EditText editText) {


        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                String text = editText.getText().toString();

                // 获取系统剪贴板
                ClipboardManager clipboard = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
                // 创建一个剪贴数据集，包含一个普通文本数据条目（需要复制的数据）
                ClipData clipData = ClipData.newPlainText(null, text);
                // 把数据集设置（复制）到剪贴板
                clipboard.setPrimaryClip(clipData);
                Toast.makeText(context,"复制成功！ 内容："+text, Toast.LENGTH_SHORT).show();
            }
        });

    }


    //进制转换
    private void binaryConversion(String str,int radix){
        two = new BigInteger(str,radix).toString(2);  //radix转二
        eight = new BigInteger(str, radix).toString(8);//radix转八
        ten = new BigInteger(str, radix).toString(10);//radix转十
        sixteen =new BigInteger(str, radix).toString(16);//radix转十六
    }


    //显示
    private void display(String two, String eight, String ten, String sixteen){
        autoChange = true;   //设置为true  当执行到addTextChangedListener 时 为true时 不会因为setText 改变文本状态而再去递归调用导致溢出栈
        two_sys.setText(two+"");
        autoChange = true;
        eight_sys.setText(eight+"");
        autoChange = true;
        ten_sys.setText(ten+"");
        autoChange = true;
        sixteen_sys.setText(sixteen+"");
    }
}
